//Static成员
class Student{
    //这种的也是成员变量
    //也叫做非静态成员变量------>属于对象，那么就是访问方式是对象的引用即 .xxx
    private String name;
    private int age;
//    public String classRoom;

    //静态成员变量
    public static String classRoom;//也是成员变量，但是应该称之为静态成员变量

    //构造方法
    public Student(){

    }

    //成员方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    /**
     * 上述是对于私有的成员变量创建的接口
     */
    public void eat(){
        System.out.println(this.name + "正在吃饭");
    }
    public void show(){
        System.out.println("姓名" + this.name + "年龄" + this.age );
    }

    public static void func(){

        System.out.println("这是一个静态的方法");
        //show();//这么直接去调用的类中的非静态方法，会直接报错
        //所以在静态方法内部不能直接调用非静态方法
        //必须要通过类进行引用
        Student student = new Student();
        student.show();

    }
}
public class Test {
    public static void main1(String[] args) {
        Student student1 = new Student("A",10);
        //student1.classRoom = "109";

        Student student2 = new Student("B",3);
        //student2.classRoom = "109";

        Student student3 = new Student("C",15);
        //student3.classRoom = "109";



        //如果我们把这些学生放到一个教室里，那么这个时候应该定义classRoom
        //每次调用都用了实例化对象，然后每次都把三个对象放在堆中
        //然后只有变化的是name和age，classRoom不去变化，所以遇到这种情况，我们可以用static

        //当使用static时候，我们通过调试来进行，可以发现对象实例化出并没有classRoom
        //所以当把classRoom使用static修饰之后，就不存在与对象之中了
        //那么此时的classRoom被拿到了方法区（虚拟机栈）并被赋值 “109”
        //那么此时的所有的对象都会共用了classRoom这个成员变量
        /**
         * 这个时候被static修饰，就不能用用调用的方式，所以我们就需要别的方式来进行访问
         */

        Student.classRoom = "109";//因为它被static修饰完之后，就不再对象的里面，所以说怕我们就不需要对象的引用了（即调用）
        System.out.println(Student.classRoom);
        Student.func();//也是直接这么用类名去调用

        //静态变量的实现不需要类的对象的引用（不依赖于对象）

        //静态成员方法和静态变量也称之为类方法，类变量

    }

    //静态方法的调用不需要对象，例如：
    public static int func1(int a,int b){
        return a + b;
    }
    public static void main2(String[] args) {
        System.out.println(func1(11, 29));
    }
    //所以要想调用非静态的
    public static int func2(int a,int b){
        return a + b;
    }

    public static void main(String[] args) {
        Test test = new Test();
        System.out.println(test.func2(1,4));
    }//所以要通过对象的引用来调用这个方法

    //总结： 静态方法不能直接调用非静态的成员方法或者调用成员变量，static方法中不能使用this
    //一个非静态方法可以调用静态方法，因为静态方法的调用不需要对象的引用，但是我们也可以让其强制依赖

    //在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对
    //象，是所有对象所共享的。
    //static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。
    //【静态成员变量特性】：
    //1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
    //2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
    //3. 类变量存储在方法区当中
    //4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)



    //java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。
    //如果需要访问类中的静态方法，我们需要通过类名去访问
    //【静态方法特性】:
    //1. 不属于某个具体的对象，是类方法
    //2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
    //3. 不能在静态方法中直接访问任何非静态成员变量，需要类的对象的引用
    //4. 静态方法中不能直接调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用，我们可以用对象的引用来进行间接调用
}
